# -*- coding: utf-8 -*-
"""
标定功能数据模型
负责管理标定界面的菜单结构和检测项数据
"""

from PySide2.QtCore import QAbstractListModel, QModelIndex, Qt, Signal
from PySide2.QtGui import QStandardItemModel, QStandardItem, QFont, QIcon, QPixmap
from ..handlercore.language_manager import LanguageManager
import os


class CalibrationFunctionModel(QAbstractListModel):
    """
    标定功能菜单数据模型
    支持两级菜单结构，包含展开/折叠和选择状态管理
    """
    
    # 信号定义
    item_selected = Signal(str, bool)  # 项目选择信号，传递项目名称和是否为子项
    
    def __init__(self, parent=None):
        super(CalibrationFunctionModel, self).__init__(parent)
        
        # 获取语言管理器实例
        self.language_manager = LanguageManager()
        
        # 菜单结构数据 - 使用翻译键
        self.menu_structure_keys = {
            "calibration_menu_laser_yaw": {"clicked": False, "expanded": False},
            "calibration_menu_laser_joint": {"clicked": False, "expanded": False},
            "calibration_menu_mid360": {"clicked": False, "expanded": False},
            "calibration_menu_fork_camera": {
                "clicked": False,
                "expanded": False,
                "sub_items": {
                    "calibration_menu_fork_camera_sub1": {"clicked": False}
                }
            },
            "calibration_menu_recognition_camera": {
                "clicked": False,
                "expanded": False,
                "sub_items": {
                    "calibration_menu_recognition_camera_sub1": {"clicked": False},
                    "calibration_menu_recognition_camera_sub2": {"clicked": False}
                }
            }
        }
        
        # 当前选中的项目
        self.selected_item = None
        
        # 连接语言切换信号
        self.language_manager.language_changed.connect(self._on_language_changed)
        
        # 构建显示列表
        self.display_items = []
        self.build_display_list()
    
    def _on_language_changed(self, language_data):
        """语言切换时重新构建显示列表"""
        # 重新构建显示列表
        self.build_display_list()
        
        # 发出数据变化信号
        self.layoutChanged.emit()
    
    def build_display_list(self):
        """构建用于显示的扁平化列表"""
        self.display_items.clear()
        
        for main_key, main_data in self.menu_structure_keys.items():
            # 获取显示文本
            main_display_text = self.language_manager.get_text(main_key, main_key)
            
            # 添加主项目
            item_info = {
                "name": main_display_text,
                "key": main_key,  # 保存翻译键
                "level": 0,  # 0表示主项目
                "is_expanded": main_data.get("expanded", False),
                "is_selected": main_data.get("clicked", False),
                "has_children": "sub_items" in main_data
            }
            self.display_items.append(item_info)
            
            # 如果有子项目且已展开，添加子项目
            if "sub_items" in main_data and main_data.get("expanded", False):
                for sub_key, sub_data in main_data["sub_items"].items():
                    # 获取子项显示文本
                    sub_display_text = self.language_manager.get_text(sub_key, sub_key)
                    
                    sub_item_info = {
                        "name": sub_display_text,
                        "key": sub_key,  # 保存翻译键
                        "level": 1,  # 1表示子项目
                        "is_expanded": False,
                        "is_selected": sub_data.get("clicked", False),
                        "has_children": False,
                        "parent_key": main_key  # 保存父项的翻译键
                    }
                    self.display_items.append(sub_item_info)
    
    def rowCount(self, parent=QModelIndex()):
        """返回行数"""
        return len(self.display_items)
    
    def data(self, index, role=Qt.DisplayRole):
        """返回指定索引的数据"""
        if not index.isValid() or index.row() >= len(self.display_items):
            return None
        
        item = self.display_items[index.row()]
        
        if role == Qt.DisplayRole:
            # 根据层级添加缩进，不再在文本中添加箭头
            indent = "    " if item["level"] == 1 else ""
            return f"{indent}{item['name']}"
        
        elif role == Qt.DecorationRole:
            # 为有子项的主项目添加箭头图标
            if item["has_children"] and item["level"] == 0:
                return self._get_arrow_icon(item["is_expanded"])
            return None
        
        elif role == Qt.BackgroundRole:
            # 选中状态的背景色 - 使用更协调的颜色
            if item["is_selected"]:
                from PySide2.QtGui import QColor
                # 使用与主题一致的蓝色，带有透明度效果
                return QColor(42, 130, 228, 77)  # rgba(42, 130, 228, 0.3) 的255值表示
        
        elif role == Qt.ForegroundRole:
            # 选中状态的文字颜色
            if item["is_selected"]:
                from PySide2.QtGui import QColor
                return QColor(255, 255, 255)  # 白色文字，提高对比度
        
        elif role == Qt.FontRole:
            # 主项目使用粗体字体，选中项目也使用粗体
            font = QFont()
            if item["level"] == 0:
                font.setBold(True)
            elif item["is_selected"]:
                font.setBold(True)  # 选中的子项目也使用粗体
            return font
        
        # 自定义角色：用于UI层获取状态信息
        elif role == Qt.UserRole:
            # 返回项目的完整状态信息
            return {
                "is_selected": item["is_selected"],
                "level": item["level"],
                "has_children": item["has_children"],
                "is_expanded": item.get("is_expanded", False)
            }
        
        elif role == Qt.UserRole + 1:
            # 返回是否为选中状态（用于样式判断）
            return item["is_selected"]
        
        return None
    
    def _get_arrow_icon(self, is_expanded):
        """获取箭头图标"""
        try:
            if is_expanded:
                arrow_pixmap = QPixmap(":/mqss/down.svg")
            else:
                arrow_pixmap = QPixmap(":/mqss/caret_left.svg")
            
            if not arrow_pixmap.isNull():
                return QIcon(arrow_pixmap)
            
            # 如果资源加载失败，返回None
            return None
            
        except Exception as e:
            print(f"加载箭头图标失败: {e}")
            return None
    
    def handle_item_click(self, index):
        """处理项目点击事件"""
        if not index.isValid() or index.row() >= len(self.display_items):
            return
        
        item = self.display_items[index.row()]
        item_key = item["key"]  # 使用翻译键
        item_name = item["name"]  # 显示名称
        
        # 重置所有选择状态
        self.reset_selection_states()
        
        if item["level"] == 0:  # 主项目
            if item["has_children"]:
                # 有子项目的主项目，切换展开/折叠状态
                self.menu_structure_keys[item_key]["expanded"] = not self.menu_structure_keys[item_key]["expanded"]
                self.menu_structure_keys[item_key]["clicked"] = True
                # 发送选择信号（使用翻译键，主项目，不能开始标定）
                self.item_selected.emit(item_key, False)
            else:
                # 没有子项目的主项目，直接选中
                self.menu_structure_keys[item_key]["clicked"] = True
                self.selected_item = item_key  # 保存翻译键
                # 发送选择信号（使用翻译键，主项目，可以开始标定）
                self.item_selected.emit(item_key, True)
        
        else:  # 子项目
            # 选中子项目
            parent_key = item["parent_key"]  # 使用父项的翻译键
            self.menu_structure_keys[parent_key]["sub_items"][item_key]["clicked"] = True
            self.selected_item = item_key  # 保存翻译键
            # 发送选择信号（使用翻译键，子项目）
            self.item_selected.emit(item_key, True)
        
        # 重新构建显示列表并刷新视图
        self.beginResetModel()
        self.build_display_list()
        self.endResetModel()
    
    def reset_selection_states(self):
        """重置所有选择状态，但保持展开状态"""
        for main_key, main_data in self.menu_structure_keys.items():
            main_data["clicked"] = False
            if "sub_items" in main_data:
                for sub_key in main_data["sub_items"]:
                    main_data["sub_items"][sub_key]["clicked"] = False
        
        self.selected_item = None
    
    def reset_all_states(self):
        """重置所有状态，包括展开状态"""
        for main_key, main_data in self.menu_structure_keys.items():
            main_data["clicked"] = False
            main_data["expanded"] = False
            if "sub_items" in main_data:
                for sub_key in main_data["sub_items"]:
                    main_data["sub_items"][sub_key]["clicked"] = False
        
        self.selected_item = None
        
        # 重新构建显示列表并刷新视图
        self.beginResetModel()
        self.build_display_list()
        self.endResetModel()
    
    def get_selected_item(self):
        """获取当前选中的项目"""
        return self.selected_item


class DetectionItemModel(QStandardItemModel):
    """
    检测项数据模型
    管理右侧检测项列表的数据
    """
    
    def __init__(self, parent=None):
        super(DetectionItemModel, self).__init__(parent)
        
        # 获取语言管理器实例
        self.language_manager = LanguageManager()
        
        # 检测项数据键值对应 - 现在支持动态设置
        self.detection_data_keys = {}
        
        # 检测项显示名称映射
        self.detection_display_names = {
            "上激光数据": "calibration_detection_top_laser",
            "下激光数据": "calibration_detection_bottom_laser", 
            "mid360数据": "calibration_detection_mid360",
            "左叉臂相机": "calibration_detection_left_fork_camera",
            "右叉臂相机": "calibration_detection_right_fork_camera",
            "系统环境": "calibration_detection_system_env"
        }
        
        # 连接语言切换信号
        self.language_manager.language_changed.connect(self._on_language_changed)
        
        # 初始化为空状态
        self.clear_detection_data()
    
    def _update_model(self):
        """更新模型数据"""
        self.clear()
        
        # 使用翻译键设置表头
        detection_title = self.language_manager.get_text("calibration_detection_title", "检测项")
        status_title = self.language_manager.get_text("calibration_status_title", "状态")
        self.setHorizontalHeaderLabels([detection_title, status_title])
        
        # 如果没有检测数据，显示空状态
        if not self.detection_data_keys:
            self._show_empty_state()
            return
        
        for item_key, status in self.detection_data_keys.items():
            # 获取显示名称
            display_name = item_key
            # 查找对应的翻译键
            translation_key = self.detection_display_names.get(item_key, item_key)
            
            # 获取翻译文本，如果没有翻译则使用显示名称
            item_name = self.language_manager.get_text(translation_key, display_name)
            name_item = QStandardItem(item_name)
            name_item.setEditable(False)
            
            # 获取状态翻译文本
            status_text = self.language_manager.get_text("calibration_status_normal", "正常") if status else self.language_manager.get_text("calibration_status_abnormal", "异常")
            status_item = QStandardItem(status_text)
            status_item.setEditable(False)
            
            # 设置状态颜色
            if status:
                status_item.setData("color: green;", Qt.UserRole + 1)
            else:
                status_item.setData("color: red;", Qt.UserRole + 1)
            
            self.appendRow([name_item, status_item])
    
    def _show_empty_state(self):
        """显示空状态"""
        # 添加一个提示行，表示未选择标定功能
        hint_item = QStandardItem(self.language_manager.get_text("calibration_no_selection", "请选择标定功能"))
        hint_item.setEditable(False)
        hint_item.setData("color: #888888;", Qt.UserRole + 1)  # 灰色文字
        
        empty_item = QStandardItem("")
        empty_item.setEditable(False)
        
        self.appendRow([hint_item, empty_item])
    
    def _on_language_changed(self, language_data):
        """语言切换时更新模型"""
        self._update_model()
    
    def update_detection_data(self, data):
        """更新检测数据"""
        if isinstance(data, dict):
            self.detection_data_keys.update(data)
            self._update_model()
    
    def set_detection_data_for_calibration(self, required_items, status_dict):
        """
        为特定标定类型设置检测数据
        
        Args:
            required_items: 必需的检测项列表
            status_dict: 检测项状态字典
        """
        # 清空当前数据
        self.detection_data_keys.clear()
        
        # 设置新的检测数据
        for item in required_items:
            self.detection_data_keys[item] = status_dict.get(item, False)
        
        # 更新模型显示
        self._update_model()
    
    def get_detection_data(self):
        """获取检测数据"""
        return self.detection_data_keys.copy()
    
    def set_item_status(self, item_key, status):
        """设置单个检测项状态"""
        if item_key in self.detection_data_keys:
            self.detection_data_keys[item_key] = status
            self._update_model()
    
    def clear_detection_data(self):
        """清空检测项数据，用于初始状态显示"""
        self.detection_data_keys.clear()
        self._update_model()
    
    def headerData(self, section, orientation, role=Qt.DisplayRole):
        """重写表头数据方法，设置表头居中对齐和样式"""
        if orientation == Qt.Horizontal:
            if role == Qt.TextAlignmentRole:
                # 设置表头文字居中对齐
                return Qt.AlignCenter
            elif role == Qt.FontRole:
                # 设置表头字体
                font = QFont()
                font.setBold(True)  # 粗体
                font.setPointSize(10)  # 字体大小
                return font
            elif role == Qt.ForegroundRole:
                # 设置表头文字颜色
                from PySide2.QtGui import QColor
                return QColor(60, 60, 60)  # 深灰色
        
        # 调用父类方法处理其他情况
        return super(DetectionItemModel, self).headerData(section, orientation, role)
    
    def data(self, index, role=Qt.DisplayRole):
        """重写data方法，设置第二列数据居中对齐"""
        if role == Qt.TextAlignmentRole and index.column() == 1:
            # 第二列（状态列）居中对齐
            return Qt.AlignCenter
        
        # 调用父类方法处理其他情况
        return super(DetectionItemModel, self).data(index, role)